package com.warm.pump.module.sys.dao.gen;

import java.util.List;
import java.util.Map;
import java.util.Date;
import java.math.BigDecimal;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

import com.warm.pump.frame.gen.bean.PageBean;
import com.warm.pump.frame.gen.util.TypeCast;
import com.warm.pump.frame.gen.exception.ServiceException;
import com.warm.pump.module.sys.bean.po.gen.DictGroup;
import com.warm.pump.module.sys.mapper.gen.DictGroupMapper;
import com.warm.pump.module.sys.bean.po.gen.DictGroupExample;

@Repository
public class DictGroupDao {
    // 日志对象
    private transient Log log = LogFactory.getLog(this.getClass());
    @Autowired
    private DictGroupMapper dictGroupMapper;

    // 增加一个后台DictGroup表

    public boolean insert(DictGroup dictGroup) {
        try {
            dictGroupMapper.insert(dictGroup);
            log.debug("后台DictGroup表增加成功");
            return true;
        } catch (Exception e) {
            log.debug("后台DictGroup表增加失败");
            throw new ServiceException("后台DictGroup表增加失败", e);
        }
    }
    // 增加一个后台DictGroup表Selective

    public boolean insertSelective(DictGroup dictGroup) {
        try {
            dictGroupMapper.insertSelective(dictGroup);
            log.debug("后台DictGroup表增加成功");
            return true;
        } catch (Exception e) {
            log.debug("后台DictGroup表增加失败");
            throw new ServiceException("后台DictGroup表增加失败", e);
        }
    }

    // 删除一个后台DictGroup表

    public boolean deleteByPrimaryKey(Long id) {
        try {
            dictGroupMapper.deleteByPrimaryKey(id);
            log.debug("后台DictGroup表删除成功");
            return true;
        } catch (Exception e) {
            log.debug("后台DictGroup表删除失败");
            throw new ServiceException("后台DictGroup表删除失败", e);
        }
    }
    // 删除一个后台DictGroup表byMap

    public boolean deleteByMap(Map dictGroupMap) {
        try {
            dictGroupMapper.deleteByExample(createDictGroupExample(dictGroupMap, null, null));
            log.debug("后台DictGroup根据Map删除成功");
            return true;
        } catch (Exception e) {
            log.debug("后台DictGroup根据GroupID删除失败");
            throw new ServiceException("后台DictGroup根据object删除失败", e);
        }
    }
    // 修改一个后台DictGroup表

    public boolean updateByPrimaryKey(DictGroup dictGroup) {
        try {
            dictGroupMapper.updateByPrimaryKey(dictGroup);
            log.debug("后台DictGroup表修改成功");
            return true;
        } catch (Exception e) {
            log.debug("后台DictGroup表修改失败");
            throw new ServiceException("后台DictGroup表修改失败", e);
        }
    }
    // 修改一个后台DictGroup表Selective

    public boolean updateByPrimaryKeySelective(DictGroup dictGroup) {
        try {
            dictGroupMapper.updateByPrimaryKeySelective(dictGroup);
            log.debug("后台DictGroup表修改成功");
            return true;
        } catch (Exception e) {
            log.debug("后台DictGroup表修改失败");
            throw new ServiceException("后台DictGroup表修改失败", e);
        }
    }
    // 修改一个后台DictGroup表

    public boolean updateByMap(DictGroup dictGroup, Map dictGroupMap) {
        try {
            dictGroupMapper.updateByExample(dictGroup, createDictGroupExample(dictGroupMap, null, null));
            log.debug("后台批量DictGroup表修改成功");
            return true;
        } catch (Exception e) {
            log.debug("后台批量DictGroup表修改失败");
            throw new ServiceException("后台DictGroup表批量修改失败", e);
        }
    }
    // 修改一个后台DictGroup表Selective

    public boolean updateByMapSelective(DictGroup dictGroup, Map dictGroupMap) {
        try {
            dictGroupMapper.updateByExampleSelective(dictGroup, createDictGroupExample(dictGroupMap, null, null));
            log.debug("后台批量DictGroup表修改成功");
            return true;
        } catch (Exception e) {
            log.debug("后台批量DictGroup表修改失败");
            throw new ServiceException("后台DictGroup表批量修改失败", e);
        }
    }

    // 查询一个后台DictGroup表

    public DictGroup selectByPrimaryKey(Long id) {
        return dictGroupMapper.selectByPrimaryKey(id);
    }

    // 查询一个后台DictGroup表-根据map

    public DictGroup selectByMap(Map dictGroupMap) {
        List<DictGroup> list = getListByMap(dictGroupMap);
        if (list == null || list.isEmpty()) {
            return null;
        } else {
            return list.get(0);
        }
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    // 查询所有后台DictGroup表

    public List<DictGroup> getListByMap(Map dictGroupMap) {

        return dictGroupMapper.selectByExample(createDictGroupExample(dictGroupMap, null, null));
    }

    //统计后台DictGroup表数量

    public int countTotalByMap(Map dictGroupMap) {

        return dictGroupMapper.countByExample(createDictGroupExample(dictGroupMap, null, null));
    }


    public List<DictGroup> getListByMapPage(Map dictGroupMap, int limitStart,
                                            int limitOffset) {

        return dictGroupMapper.selectByExample(createDictGroupExample(dictGroupMap, limitStart, limitOffset));
    }


    public PageBean getPageBeanByMap(Map dictGroupMap, int pageNo, int pageSize) {
        Integer count = countTotalByMap(dictGroupMap);
        PageBean pageBean = new PageBean();
        pageBean.setCount(count);
        pageBean.setPageNo(pageNo);
        pageBean.setPageSize(pageSize);
        int limitStart = pageBean.getStartNo();
        int limitOffset = pageSize;
        pageBean.setData(dictGroupMapper.selectByExample(createDictGroupExample(dictGroupMap, limitStart, limitOffset)));
        return pageBean;
    }

    private DictGroupExample createDictGroupExample(Map dictGroupMap, Integer limitStart, Integer limitOffset) {
        DictGroupExample dictGroupEx = new DictGroupExample();
        DictGroupExample.Criteria c = dictGroupEx.createCriteria();
        Long id_null = TypeCast.getLong(dictGroupMap.get("id_null"));
        Long id_notNull = TypeCast.getLong(dictGroupMap.get("id_notNull"));
        Long id = TypeCast.getLong(dictGroupMap.get("id"));
        Long id_not = TypeCast.getLong(dictGroupMap.get("id_not"));
        Long id_greater = TypeCast.getLong(dictGroupMap.get("id_greater"));
        Long id_greaterEqual = TypeCast.getLong(dictGroupMap.get("id_greaterEqual"));
        Long id_less = TypeCast.getLong(dictGroupMap.get("id_less"));
        Long id_lessEqual = TypeCast.getLong(dictGroupMap.get("id_lessEqual"));
        List<Long> id_in = TypeCast.getLongList(dictGroupMap.get("id_in"));
        List<Long> id_notIn = TypeCast.getLongList(dictGroupMap.get("id_notIn"));
        Long id_between1 = TypeCast.getLong(dictGroupMap.get("id_between1"));
        Long id_between2 = TypeCast.getLong(dictGroupMap.get("id_between2"));
        Long id_notBetween1 = TypeCast.getLong(dictGroupMap.get("id_notBetween1"));
        Long id_notBetween2 = TypeCast.getLong(dictGroupMap.get("id_notBetween2"));

        if (id_null != null) {
            c.andIdIsNull();
        }
        if (id_notNull != null) {
            c.andIdIsNotNull();
        }
        if (id != null) {
            c.andIdEqualTo(id);
        }
        if (id_not != null) {
            c.andIdNotEqualTo(id_not);
        }
        if (id_greater != null) {
            c.andIdGreaterThan(id_greater);
        }
        if (id_greaterEqual != null) {
            c.andIdGreaterThanOrEqualTo(id_greaterEqual);
        }
        if (id_less != null) {
            c.andIdLessThan(id_less);
        }
        if (id_lessEqual != null) {
            c.andIdLessThanOrEqualTo(id_lessEqual);
        }
        if (id_in != null) {
            c.andIdIn(id_in);
        }
        if (id_notIn != null) {
            c.andIdNotIn(id_notIn);
        }
        if (id_between1 != null) {
            c.andIdBetween(id_between1, id_between2);
        }
        if (id_notBetween1 != null) {
            c.andIdNotBetween(id_notBetween1, id_notBetween2);
        }
        String groupCode_null = TypeCast.getString(dictGroupMap.get("groupCode_null"));
        String groupCode_notNull = TypeCast.getString(dictGroupMap.get("groupCode_notNull"));
        String groupCode = TypeCast.getString(dictGroupMap.get("groupCode"));
        String groupCode_not = TypeCast.getString(dictGroupMap.get("groupCode_not"));
        String groupCode_greater = TypeCast.getString(dictGroupMap.get("groupCode_greater"));
        String groupCode_greaterEqual = TypeCast.getString(dictGroupMap.get("groupCode_greaterEqual"));
        String groupCode_less = TypeCast.getString(dictGroupMap.get("groupCode_less"));
        String groupCode_lessEqual = TypeCast.getString(dictGroupMap.get("groupCode_lessEqual"));
        String groupCode_like = TypeCast.getString(dictGroupMap.get("groupCode_like"));
        String groupCode_notLike = TypeCast.getString(dictGroupMap.get("groupCode_notLike"));
        List<String> groupCode_in = TypeCast.getStringList(dictGroupMap.get("groupCode_in"));
        List<String> groupCode_notIn = TypeCast.getStringList(dictGroupMap.get("groupCode_notIn"));
        String groupCode_between1 = TypeCast.getString(dictGroupMap.get("groupCode_between1"));
        String groupCode_between2 = TypeCast.getString(dictGroupMap.get("groupCode_between2"));
        String groupCode_notBetween1 = TypeCast.getString(dictGroupMap.get("groupCode_notBetween1"));
        String groupCode_notBetween2 = TypeCast.getString(dictGroupMap.get("groupCode_notBetween2"));

        if (groupCode_null != null) {
            c.andGroupCodeIsNull();
        }
        if (groupCode_notNull != null) {
            c.andGroupCodeIsNotNull();
        }
        if (groupCode != null) {
            c.andGroupCodeEqualTo(groupCode);
        }
        if (groupCode_not != null) {
            c.andGroupCodeNotEqualTo(groupCode_not);
        }
        if (groupCode_greater != null) {
            c.andGroupCodeGreaterThan(groupCode_greater);
        }
        if (groupCode_greaterEqual != null) {
            c.andGroupCodeGreaterThanOrEqualTo(groupCode_greaterEqual);
        }
        if (groupCode_less != null) {
            c.andGroupCodeLessThan(groupCode_less);
        }
        if (groupCode_lessEqual != null) {
            c.andGroupCodeLessThanOrEqualTo(groupCode_lessEqual);
        }
        if (groupCode_like != null) {
            c.andGroupCodeLike(groupCode_like);
        }
        if (groupCode_notLike != null) {
            c.andGroupCodeNotLike(groupCode_notLike);
        }
        if (groupCode_in != null) {
            c.andGroupCodeIn(groupCode_in);
        }
        if (groupCode_notIn != null) {
            c.andGroupCodeNotIn(groupCode_notIn);
        }
        if (groupCode_between1 != null) {
            c.andGroupCodeBetween(groupCode_between1, groupCode_between2);
        }
        if (groupCode_notBetween1 != null) {
            c.andGroupCodeNotBetween(groupCode_notBetween1, groupCode_notBetween2);
        }
        String groupName_null = TypeCast.getString(dictGroupMap.get("groupName_null"));
        String groupName_notNull = TypeCast.getString(dictGroupMap.get("groupName_notNull"));
        String groupName = TypeCast.getString(dictGroupMap.get("groupName"));
        String groupName_not = TypeCast.getString(dictGroupMap.get("groupName_not"));
        String groupName_greater = TypeCast.getString(dictGroupMap.get("groupName_greater"));
        String groupName_greaterEqual = TypeCast.getString(dictGroupMap.get("groupName_greaterEqual"));
        String groupName_less = TypeCast.getString(dictGroupMap.get("groupName_less"));
        String groupName_lessEqual = TypeCast.getString(dictGroupMap.get("groupName_lessEqual"));
        String groupName_like = TypeCast.getString(dictGroupMap.get("groupName_like"));
        String groupName_notLike = TypeCast.getString(dictGroupMap.get("groupName_notLike"));
        List<String> groupName_in = TypeCast.getStringList(dictGroupMap.get("groupName_in"));
        List<String> groupName_notIn = TypeCast.getStringList(dictGroupMap.get("groupName_notIn"));
        String groupName_between1 = TypeCast.getString(dictGroupMap.get("groupName_between1"));
        String groupName_between2 = TypeCast.getString(dictGroupMap.get("groupName_between2"));
        String groupName_notBetween1 = TypeCast.getString(dictGroupMap.get("groupName_notBetween1"));
        String groupName_notBetween2 = TypeCast.getString(dictGroupMap.get("groupName_notBetween2"));

        if (groupName_null != null) {
            c.andGroupNameIsNull();
        }
        if (groupName_notNull != null) {
            c.andGroupNameIsNotNull();
        }
        if (groupName != null) {
            c.andGroupNameEqualTo(groupName);
        }
        if (groupName_not != null) {
            c.andGroupNameNotEqualTo(groupName_not);
        }
        if (groupName_greater != null) {
            c.andGroupNameGreaterThan(groupName_greater);
        }
        if (groupName_greaterEqual != null) {
            c.andGroupNameGreaterThanOrEqualTo(groupName_greaterEqual);
        }
        if (groupName_less != null) {
            c.andGroupNameLessThan(groupName_less);
        }
        if (groupName_lessEqual != null) {
            c.andGroupNameLessThanOrEqualTo(groupName_lessEqual);
        }
        if (groupName_like != null) {
            c.andGroupNameLike(groupName_like);
        }
        if (groupName_notLike != null) {
            c.andGroupNameNotLike(groupName_notLike);
        }
        if (groupName_in != null) {
            c.andGroupNameIn(groupName_in);
        }
        if (groupName_notIn != null) {
            c.andGroupNameNotIn(groupName_notIn);
        }
        if (groupName_between1 != null) {
            c.andGroupNameBetween(groupName_between1, groupName_between2);
        }
        if (groupName_notBetween1 != null) {
            c.andGroupNameNotBetween(groupName_notBetween1, groupName_notBetween2);
        }
        String status_null = TypeCast.getString(dictGroupMap.get("status_null"));
        String status_notNull = TypeCast.getString(dictGroupMap.get("status_notNull"));
        String status = TypeCast.getString(dictGroupMap.get("status"));
        String status_not = TypeCast.getString(dictGroupMap.get("status_not"));
        String status_greater = TypeCast.getString(dictGroupMap.get("status_greater"));
        String status_greaterEqual = TypeCast.getString(dictGroupMap.get("status_greaterEqual"));
        String status_less = TypeCast.getString(dictGroupMap.get("status_less"));
        String status_lessEqual = TypeCast.getString(dictGroupMap.get("status_lessEqual"));
        String status_like = TypeCast.getString(dictGroupMap.get("status_like"));
        String status_notLike = TypeCast.getString(dictGroupMap.get("status_notLike"));
        List<String> status_in = TypeCast.getStringList(dictGroupMap.get("status_in"));
        List<String> status_notIn = TypeCast.getStringList(dictGroupMap.get("status_notIn"));
        String status_between1 = TypeCast.getString(dictGroupMap.get("status_between1"));
        String status_between2 = TypeCast.getString(dictGroupMap.get("status_between2"));
        String status_notBetween1 = TypeCast.getString(dictGroupMap.get("status_notBetween1"));
        String status_notBetween2 = TypeCast.getString(dictGroupMap.get("status_notBetween2"));

        if (status_null != null) {
            c.andStatusIsNull();
        }
        if (status_notNull != null) {
            c.andStatusIsNotNull();
        }
        if (status != null) {
            c.andStatusEqualTo(status);
        }
        if (status_not != null) {
            c.andStatusNotEqualTo(status_not);
        }
        if (status_greater != null) {
            c.andStatusGreaterThan(status_greater);
        }
        if (status_greaterEqual != null) {
            c.andStatusGreaterThanOrEqualTo(status_greaterEqual);
        }
        if (status_less != null) {
            c.andStatusLessThan(status_less);
        }
        if (status_lessEqual != null) {
            c.andStatusLessThanOrEqualTo(status_lessEqual);
        }
        if (status_like != null) {
            c.andStatusLike(status_like);
        }
        if (status_notLike != null) {
            c.andStatusNotLike(status_notLike);
        }
        if (status_in != null) {
            c.andStatusIn(status_in);
        }
        if (status_notIn != null) {
            c.andStatusNotIn(status_notIn);
        }
        if (status_between1 != null) {
            c.andStatusBetween(status_between1, status_between2);
        }
        if (status_notBetween1 != null) {
            c.andStatusNotBetween(status_notBetween1, status_notBetween2);
        }
        Date statusTime_null = TypeCast.getDate(dictGroupMap.get("statusTime_null"));
        Date statusTime_notNull = TypeCast.getDate(dictGroupMap.get("statusTime_notNull"));
        Date statusTime = TypeCast.getDate(dictGroupMap.get("statusTime"));
        Date statusTime_not = TypeCast.getDate(dictGroupMap.get("statusTime_not"));
        Date statusTime_greater = TypeCast.getDate(dictGroupMap.get("statusTime_greater"));
        Date statusTime_greaterEqual = TypeCast.getDate(dictGroupMap.get("statusTime_greaterEqual"));
        Date statusTime_less = TypeCast.getDate(dictGroupMap.get("statusTime_less"));
        Date statusTime_lessEqual = TypeCast.getDate(dictGroupMap.get("statusTime_lessEqual"));
        List<Date> statusTime_in = TypeCast.getDateList(dictGroupMap.get("statusTime_in"));
        List<Date> statusTime_notIn = TypeCast.getDateList(dictGroupMap.get("statusTime_notIn"));
        Date statusTime_between1 = TypeCast.getDate(dictGroupMap.get("statusTime_between1"));
        Date statusTime_between2 = TypeCast.getDate(dictGroupMap.get("statusTime_between2"));
        Date statusTime_notBetween1 = TypeCast.getDate(dictGroupMap.get("statusTime_notBetween1"));
        Date statusTime_notBetween2 = TypeCast.getDate(dictGroupMap.get("statusTime_notBetween2"));

        if (statusTime_null != null) {
            c.andStatusTimeIsNull();
        }
        if (statusTime_notNull != null) {
            c.andStatusTimeIsNotNull();
        }
        if (statusTime != null) {
            c.andStatusTimeEqualTo(statusTime);
        }
        if (statusTime_not != null) {
            c.andStatusTimeNotEqualTo(statusTime_not);
        }
        if (statusTime_greater != null) {
            c.andStatusTimeGreaterThan(statusTime_greater);
        }
        if (statusTime_greaterEqual != null) {
            c.andStatusTimeGreaterThanOrEqualTo(statusTime_greaterEqual);
        }
        if (statusTime_less != null) {
            c.andStatusTimeLessThan(statusTime_less);
        }
        if (statusTime_lessEqual != null) {
            c.andStatusTimeLessThanOrEqualTo(statusTime_lessEqual);
        }
        if (statusTime_in != null) {
            c.andStatusTimeIn(statusTime_in);
        }
        if (statusTime_notIn != null) {
            c.andStatusTimeNotIn(statusTime_notIn);
        }
        if (statusTime_between1 != null) {
            c.andStatusTimeBetween(statusTime_between1, statusTime_between2);
        }
        if (statusTime_notBetween1 != null) {
            c.andStatusTimeNotBetween(statusTime_notBetween1, statusTime_notBetween2);
        }
        Integer isSys_null = TypeCast.getInteger(dictGroupMap.get("isSys_null"));
        Integer isSys_notNull = TypeCast.getInteger(dictGroupMap.get("isSys_notNull"));
        Integer isSys = TypeCast.getInteger(dictGroupMap.get("isSys"));
        Integer isSys_not = TypeCast.getInteger(dictGroupMap.get("isSys_not"));
        Integer isSys_greater = TypeCast.getInteger(dictGroupMap.get("isSys_greater"));
        Integer isSys_greaterEqual = TypeCast.getInteger(dictGroupMap.get("isSys_greaterEqual"));
        Integer isSys_less = TypeCast.getInteger(dictGroupMap.get("isSys_less"));
        Integer isSys_lessEqual = TypeCast.getInteger(dictGroupMap.get("isSys_lessEqual"));
        List<Integer> isSys_in = TypeCast.getIntegerList(dictGroupMap.get("isSys_in"));
        List<Integer> isSys_notIn = TypeCast.getIntegerList(dictGroupMap.get("isSys_notIn"));
        Integer isSys_between1 = TypeCast.getInteger(dictGroupMap.get("isSys_between1"));
        Integer isSys_between2 = TypeCast.getInteger(dictGroupMap.get("isSys_between2"));
        Integer isSys_notBetween1 = TypeCast.getInteger(dictGroupMap.get("isSys_notBetween1"));
        Integer isSys_notBetween2 = TypeCast.getInteger(dictGroupMap.get("isSys_notBetween2"));

        if (isSys_null != null) {
            c.andIsSysIsNull();
        }
        if (isSys_notNull != null) {
            c.andIsSysIsNotNull();
        }
        if (isSys != null) {
            c.andIsSysEqualTo(isSys);
        }
        if (isSys_not != null) {
            c.andIsSysNotEqualTo(isSys_not);
        }
        if (isSys_greater != null) {
            c.andIsSysGreaterThan(isSys_greater);
        }
        if (isSys_greaterEqual != null) {
            c.andIsSysGreaterThanOrEqualTo(isSys_greaterEqual);
        }
        if (isSys_less != null) {
            c.andIsSysLessThan(isSys_less);
        }
        if (isSys_lessEqual != null) {
            c.andIsSysLessThanOrEqualTo(isSys_lessEqual);
        }
        if (isSys_in != null) {
            c.andIsSysIn(isSys_in);
        }
        if (isSys_notIn != null) {
            c.andIsSysNotIn(isSys_notIn);
        }
        if (isSys_between1 != null) {
            c.andIsSysBetween(isSys_between1, isSys_between2);
        }
        if (isSys_notBetween1 != null) {
            c.andIsSysNotBetween(isSys_notBetween1, isSys_notBetween2);
        }
        String remark_null = TypeCast.getString(dictGroupMap.get("remark_null"));
        String remark_notNull = TypeCast.getString(dictGroupMap.get("remark_notNull"));
        String remark = TypeCast.getString(dictGroupMap.get("remark"));
        String remark_not = TypeCast.getString(dictGroupMap.get("remark_not"));
        String remark_greater = TypeCast.getString(dictGroupMap.get("remark_greater"));
        String remark_greaterEqual = TypeCast.getString(dictGroupMap.get("remark_greaterEqual"));
        String remark_less = TypeCast.getString(dictGroupMap.get("remark_less"));
        String remark_lessEqual = TypeCast.getString(dictGroupMap.get("remark_lessEqual"));
        String remark_like = TypeCast.getString(dictGroupMap.get("remark_like"));
        String remark_notLike = TypeCast.getString(dictGroupMap.get("remark_notLike"));
        List<String> remark_in = TypeCast.getStringList(dictGroupMap.get("remark_in"));
        List<String> remark_notIn = TypeCast.getStringList(dictGroupMap.get("remark_notIn"));
        String remark_between1 = TypeCast.getString(dictGroupMap.get("remark_between1"));
        String remark_between2 = TypeCast.getString(dictGroupMap.get("remark_between2"));
        String remark_notBetween1 = TypeCast.getString(dictGroupMap.get("remark_notBetween1"));
        String remark_notBetween2 = TypeCast.getString(dictGroupMap.get("remark_notBetween2"));

        if (remark_null != null) {
            c.andRemarkIsNull();
        }
        if (remark_notNull != null) {
            c.andRemarkIsNotNull();
        }
        if (remark != null) {
            c.andRemarkEqualTo(remark);
        }
        if (remark_not != null) {
            c.andRemarkNotEqualTo(remark_not);
        }
        if (remark_greater != null) {
            c.andRemarkGreaterThan(remark_greater);
        }
        if (remark_greaterEqual != null) {
            c.andRemarkGreaterThanOrEqualTo(remark_greaterEqual);
        }
        if (remark_less != null) {
            c.andRemarkLessThan(remark_less);
        }
        if (remark_lessEqual != null) {
            c.andRemarkLessThanOrEqualTo(remark_lessEqual);
        }
        if (remark_like != null) {
            c.andRemarkLike(remark_like);
        }
        if (remark_notLike != null) {
            c.andRemarkNotLike(remark_notLike);
        }
        if (remark_in != null) {
            c.andRemarkIn(remark_in);
        }
        if (remark_notIn != null) {
            c.andRemarkNotIn(remark_notIn);
        }
        if (remark_between1 != null) {
            c.andRemarkBetween(remark_between1, remark_between2);
        }
        if (remark_notBetween1 != null) {
            c.andRemarkNotBetween(remark_notBetween1, remark_notBetween2);
        }
        if (dictGroupMap.get("orderBy") != null) {
            dictGroupEx.setOrderByClause((String) dictGroupMap.get("orderBy"));
        }
        if (limitStart != null && limitOffset != null) {
            dictGroupEx.setLimitStart(limitStart);
            dictGroupEx.setLimitOffset(limitOffset);
        }

        return dictGroupEx;
    }
}
